.TH std::is_constant_evaluated 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::is_constant_evaluated \- std::is_constant_evaluated

.SH Synopsis
   Defined in header <type_traits>
   constexpr bool is_constant_evaluated() noexcept;  \fI(since C++20)\fP

   Detects whether the function call occurs within a constant-evaluated context.
   Returns true if the evaluation of the call occurs within the evaluation of an
   expression or conversion that is manifestly constant-evaluated; otherwise returns
   false.

   To determine whether initializers of following variables are manifestly
   constant-evaluated, compilers may first perform a trial constant evaluation:

     * variables with reference type or const-qualified integral or enumeration type;
     * static and thread local variables.

   It is not recommended to depend on the result in this case.

 int y = 0;
 const int a = std::is_constant_evaluated() ? y : 1;
 // Trial constant evaluation fails. The constant evaluation is discarded.
 // Variable a is dynamically initialized with 1

 const int b = std::is_constant_evaluated() ? 2 : y;
 // Constant evaluation with std::is_constant_evaluated() == true succeeds.
 // Variable b is statically initialized with 2

.SH Parameters

   \fI(none)\fP

.SH Return value

   true if the evaluation of the call occurs within the evaluation of an expression or
   conversion that is manifestly constant-evaluated; otherwise false.

.SH Possible implementation

   // This implementation requires C++23 if consteval.
   constexpr bool is_constant_evaluated() noexcept
   {
       if consteval
       {
           return true;
       }
       else
       {
           return false;
       }
   }

.SH Notes

   When directly used as the condition of static_assert declaration or constexpr if
   statement, std::is_constant_evaluated() always returns true.

   Because if consteval is absent in C++20, std::is_constant_evaluated is typically
   implemented using a compiler extension.

         Feature-test macro         Value    Std            Feature
   __cpp_lib_is_constant_evaluated 201811L (C++20) std::is_constant_evaluated

.SH Example


// Run this code

 #include <cmath>
 #include <iostream>
 #include <type_traits>

 constexpr double power(double b, int x)
 {
     if (std::is_constant_evaluated() && !(b == 0.0 && x < 0))
     {
         // A constant-evaluation context: Use a constexpr-friendly algorithm.
         if (x == 0)
             return 1.0;
         double r {1.0};
         double p {x > 0 ? b : 1.0 / b};
         for (auto u = unsigned(x > 0 ? x : -x); u != 0; u /= 2)
         {
             if (u & 1)
                 r *= p;
             p *= p;
         }
         return r;
     }
     else
     {
         // Let the code generator figure it out.
         return std::pow(b, double(x));
     }
 }

 int main()
 {
     // A constant-expression context
     constexpr double kilo = power(10.0, 3);
     int n = 3;
     // Not a constant expression, because n cannot be converted to an rvalue
     // in a constant-expression context
     // Equivalent to std::pow(10.0, double(n))
     double mucho = power(10.0, n);

     std::cout << kilo << " " << mucho << "\\n"; // (3)
 }

.SH Output:

 1000 1000

.SH See also

   constexpr specifier\fI(C++11)\fP specifies that the value of a variable or function can be
                              computed at compile time
                              specifies that a function is an immediate function, that
   consteval specifier(C++20) is, every call to the function must be in a constant
                              evaluation
   constinit specifier(C++20) asserts that a variable has static initialization, i.e.
                              zero initialization and constant initialization
